package com.hankai.service.impl;

import com.google.common.base.Splitter;
import com.google.common.collect.Lists;
import com.hankai.common.Const;
import com.hankai.common.ResponseCode;
import com.hankai.common.ServerResponse;
import com.hankai.dao.CartMapper;
import com.hankai.dao.ProductMapper;
import com.hankai.pojo.Cart;
import com.hankai.pojo.Product;
import com.hankai.service.ICartService;
import com.hankai.util.BigDecimalUtil;
import com.hankai.vo.CartProductVo;
import com.hankai.vo.CartVo;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.List;

/**
 * Created by hankai on 2017/6/8.
 */
@Service
public class CartServiceImpl implements ICartService {

    @Resource
    private CartMapper cartMapper;
    @Resource
    private ProductMapper productMapper;


    @Override
    public ServerResponse<CartVo> addCart(Integer userId, Integer productId, Integer count) {

        if(productId==null || count==null){
            return ServerResponse.createByError(ResponseCode.ILLEGAL_ARGUMENT.getCode(),ResponseCode.ILLEGAL_ARGUMENT.getDesc());
        }
        Cart cart = cartMapper.selectCartByUserIdAndProductId(userId,productId);
        if(cart==null){//根据用户id和产品id没有查到记录，说明不在购物车中
            Cart newCart = new Cart();
            newCart.setQuantity(count);
            newCart.setChecked(Const.Cart.CHECKED);
            newCart.setUserId(userId);
            newCart.setProductId(productId);
            cartMapper.insert(newCart);
        }else{
            //如果已经在购物车中，我们就修改它的数量
            count = cart.getQuantity()+count;
            cart.setQuantity(count);
            cartMapper.updateByPrimaryKeySelective(cart);
        }
        return getCartList(userId);
    }

    @Override
    public ServerResponse<CartVo> updateCart(Integer userId, Integer productId, Integer count) {
        if(productId==null || count==null){
            return ServerResponse.createByError(ResponseCode.ILLEGAL_ARGUMENT.getCode(),ResponseCode.ILLEGAL_ARGUMENT.getDesc());
        }
        Cart cart = cartMapper.selectCartByUserIdAndProductId(userId,productId);
        if(cart!=null){
            cart.setQuantity(count);
            cart.setUserId(userId);
        }
        cartMapper.updateByPrimaryKeySelective(cart);
        return getCartList(userId);
    }

    @Override
    public ServerResponse<CartVo> deleteCart(Integer userId, String productIds) {
        List<String> productIdList = Splitter.on(".").splitToList(productIds);
        if(CollectionUtils.isNotEmpty(productIdList)){
            cartMapper.deleteCartByUserIdAndproductIds(userId,productIdList);
        }
        return getCartList(userId);
    }

    @Override
    public ServerResponse<CartVo> getCartList(Integer userId) {
        CartVo cartVo = getCartVoLimit(userId);
        return ServerResponse.createBySuccess(cartVo);

    }

    @Override
    public ServerResponse<CartVo> updateSelectOrUnSelect(Integer userId,Integer productId, Integer checked) {
        int i = cartMapper.updateSelectOrUnSelect(userId,productId,checked);
        return getCartList(userId);
    }

    @Override
    public ServerResponse<Integer> getCount(Integer userId) {
        if(userId==null){
            return ServerResponse.createBySuccess(0);
        }
        int count = cartMapper.getCount(userId);
        return ServerResponse.createBySuccess(count);
    }

    /**
     * 计算购物车总价
     * 商品列表
     *
     * @param userId
     * @return
     */
    private CartVo getCartVoLimit(Integer userId){
        CartVo cartVo = new CartVo();
        BigDecimal cartTotalPrice = new BigDecimal("0");
        List<CartProductVo> cartProductVoList = Lists.newArrayList();
        //查出购物车列表
        List<Cart> cartList = cartMapper.getCartByUserId(userId);
        if(CollectionUtils.isNotEmpty(cartList)){
            for(Cart cart : cartList){
                CartProductVo cartProductVo = new CartProductVo();
                cartProductVo.setId(cart.getId());
                cartProductVo.setProductId(cart.getProductId());
                cartProductVo.setUserId(cart.getUserId());
                //查出每个购物车中的商品
                Product product = productMapper.selectByPrimaryKey(cart.getProductId());
                if(product!=null){
                    //将购物车cart转换成cartProductVo
                    cartProductVo.setProductName(product.getName());
                    cartProductVo.setProductMainImage(product.getMainImage());
                    cartProductVo.setProductSubTitle(product.getSubImages());
                    cartProductVo.setProductSubTitle(product.getSubtitle());
                    cartProductVo.setProductPrice(product.getPrice());
                    cartProductVo.setProductStock(product.getStock());
                    int buyLimitCount = 0;//库存
                    if(product.getStock()>=cart.getQuantity()){
                        //库存没超出，可以购买，直接赋值
                        buyLimitCount = cart.getQuantity();
                        cartProductVo.setLimiQuantity(Const.Cart.LIMIT_NUM_SUCCESS);
                    }else{
                        //超出库存，只能购买库存剩余的产品。赋值库存总量
                        buyLimitCount = product.getStock();
                        cartProductVo.setLimiQuantity(Const.Cart.LIMIT_NUM_error);
                        //更新一下购物车
                        Cart car = new Cart();
                        car.setId(cart.getId());
                        car.setQuantity(buyLimitCount);
                        cartMapper.updateByPrimaryKeySelective(car);
                    }
                    cartProductVo.setQuantity(buyLimitCount);

                    //计算总价（单价*购物车总量）
                    cartProductVo.setProductTotalPrice(BigDecimalUtil.mul(product.getPrice().doubleValue(),cartProductVo.getQuantity().doubleValue()));

                    cartProductVo.setProductChecked(cart.getChecked());
                }
                if(cart.getChecked()==Const.Cart.CHECKED){//选中状态
                    //算出总价后，将各购物车商品总价相加，算出全部总价
                    cartTotalPrice = BigDecimalUtil.add(cartTotalPrice.doubleValue(),cartProductVo.getProductTotalPrice().doubleValue());
                }
                cartProductVoList.add(cartProductVo);
            }
            cartVo.setCartTotalPrice(cartTotalPrice);
            cartVo.setCartProductVoList(cartProductVoList);
            cartVo.setAllChecked(getAllCheckedStatus(userId));
            cartVo.setImageHost("ftp.server.http.prefix");
        }
        return cartVo;
    }

    /**
     * 判断是否全选
     * @param userId
     * @return
     */
    private boolean getAllCheckedStatus(Integer userId){
        if(userId==null){
            return false;
        }
        return cartMapper.checkAllStatusByUserId(userId)==0;
    }
}
